import request from '@/utils/request'
import { getToken } from '@/utils/cookie'

/**
 * AI流式对话API - 重构版本，简化连接管理，确保一次请求只创建一个连接
 */
export default {
  // 当前活跃的连接状态
  currentConnection: null,
  currentConnectionKey: null,
  isCreatingConnection: false, // 防止并发创建连接

  /**
   * 生成连接唯一标识
   * @param {Object} data 请求参数
   * @returns {string} 连接标识
   */
  generateConnectionKey(data) {
    return `ai_stream_${data.senderId}_${data.receiverId}_${data.chatType}`
  },

  /**
   * 创建AI流式对话EventSource连接 - 重构版本
   * @param {Object} data 请求参数
   * @param {string} data.content 消息内容
   * @param {string} data.chatType 聊天类型：PRIVATE-私聊，GROUP-群聊
   * @param {number} data.receiverId 接收者ID（私聊时为用户ID，群聊时为群组ID）
   * @param {number} data.senderId 发送者ID
   * @param {string} data.senderNickname 发送者昵称
   * @returns {EventSource} SSE连接对象
   */
  createStreamChat(data) {
    // 防止并发创建连接
    if (this.isCreatingConnection) {
      console.warn('正在创建AI连接中，忽略重复请求')
      throw new Error('正在创建AI连接中，请稍候...')
    }

    // 检查是否已有活跃连接
    if (this.hasActiveConnection()) {
      console.warn('已存在活跃的AI连接，忽略重复请求')
      throw new Error('AI连接正在使用中，请稍候...')
    }

    // 设置创建状态
    this.isCreatingConnection = true

    try {
      // 生成连接唯一标识
      const connectionKey = this.generateConnectionKey(data)
      console.log('创建新的AI流式对话连接:', connectionKey)

      // 创建新连接
      const eventSource = this.createNewConnection(data, connectionKey)

      // 保存当前连接
      this.currentConnection = eventSource
      this.currentConnectionKey = connectionKey

      return eventSource
    } finally {
      // 无论成功失败都要重置创建状态
      this.isCreatingConnection = false
    }
  },

  /**
   * 创建新的EventSource连接
   * @param {Object} data 请求参数
   * @param {string} connectionKey 连接标识
   * @returns {EventSource} 连接对象
   */
  createNewConnection(data, connectionKey) {
    // 构建查询参数
    const params = new URLSearchParams()
    Object.keys(data).forEach(key => {
      if (data[key] !== null && data[key] !== undefined) {
        params.append(key, data[key])
      }
    })

    // 获取token并添加到查询参数中（EventSource不支持自定义headers）
    const token = getToken()
    if (token) {
      params.append('token', token)
    }

    // 构建URL - 使用Vite环境变量
    const baseURL = import.meta.env.VITE_APP_BASE_API
    const url = `${baseURL}/ai/stream/chat?${params.toString()}`

    console.log('创建AI流式连接URL:', url)

    // 创建EventSource连接
    const eventSource = new EventSource(url)

    // 设置基础事件监听器
    this.setupBasicListeners(eventSource, connectionKey)

    return eventSource
  },

  /**
   * 设置基础事件监听器
   * @param {EventSource} eventSource 连接对象
   * @param {string} connectionKey 连接标识
   */
  setupBasicListeners(eventSource, connectionKey) {
    // 监听连接打开事件
    eventSource.addEventListener('open', () => {
      console.log('AI流式连接已建立:', connectionKey)
    })

    // 注意：不再在这里添加error监听器，避免与ChatBox.vue中的冲突
    // 错误处理完全由ChatBox.vue负责

    // 重写close方法，确保清理
    const originalClose = eventSource.close.bind(eventSource)
    eventSource.close = () => {
      console.log('主动关闭AI流式连接:', connectionKey)
      this.cleanupCurrentConnection(connectionKey)
      originalClose()
    }
  },

  /**
   * 清理当前连接引用
   * @param {string} connectionKey 连接标识
   */
  cleanupCurrentConnection(connectionKey) {
    if (this.currentConnectionKey === connectionKey) {
      this.currentConnection = null
      this.currentConnectionKey = null
    }
  },

  /**
   * 关闭当前连接
   */
  closeCurrentConnection() {
    if (this.currentConnection && this.currentConnection.readyState !== EventSource.CLOSED) {
      console.log('关闭当前AI流式连接:', this.currentConnectionKey)
      this.currentConnection.close()
    }
  },

  /**
   * 强制关闭当前连接 - 简化版本
   */
  forceCloseCurrentConnection() {
    if (this.currentConnection) {
      console.log('强制关闭当前AI流式连接:', this.currentConnectionKey)

      // 直接清理引用和关闭连接
      const connection = this.currentConnection
      const connectionKey = this.currentConnectionKey

      this.currentConnection = null
      this.currentConnectionKey = null

      // 强制关闭连接
      if (connection.readyState !== EventSource.CLOSED) {
        connection.close()
      }

      // 异步调用后端关闭接口，不阻塞主流程
      if (connectionKey) {
        this.closeConnection(connectionKey).catch(error => {
          console.warn('强制关闭时调用后端接口失败:', error)
        })
      }
    }
  },

  /**
   * 检查是否有活跃连接
   */
  hasActiveConnection() {
    return this.currentConnection && this.currentConnection.readyState !== EventSource.CLOSED
  },

  /**
   * 获取活跃连接数
   * @returns {Promise} 请求Promise
   */
  getActiveConnectionsCount() {
    return request({
      url: '/ai/stream/connections/count',
      method: 'get'
    })
  },

  /**
   * 关闭指定会话连接
   * @param {string} sessionId 会话ID
   * @returns {Promise} 请求Promise
   */
  closeConnection(sessionId) {
    return request({
      url: `/ai/stream/connections/${sessionId}/close`,
      method: 'post'
    })
  },

  /**
   * 获取当前连接状态信息（用于调试）
   */
  getConnectionStatus() {
    return {
      hasConnection: this.currentConnection !== null,
      connectionKey: this.currentConnectionKey,
      readyState: this.currentConnection ? this.currentConnection.readyState : null
    }
  }
}
